Número de datos obtenidos y perdidos

Importamos las librerías necesarias



In [1]:

    
import pandas as pd
import matplotlib.pyplot as plt



In [2]:

    
%matplotlib inline

Importamos las librerías creadas para trabajar



In [3]:

    
import ext_datos as ext
import procesar as pro
import time_plot as tplt

Generamos los datasets de todos los días

Notas:
- Se leeran los archivos guardados en una carpeta por dia
- El problema de la configuración actual de la telemetría del auto solar es que usa software hecho para registrar datos de un motor a la vez, lo que nos obliga a usar dos instancias cada una de las cuales escribe un archivo de datos diferente, sin embargo el protocolo tcp/ip si pierde momentáneamente la conexión intenta reconectar automáticamente y los programas se reconectan al primer motor que detectan.
- Esto genera archivos mezclados, datos duplicados y pérdidas de datos
- Cree un script que automatiza separar los motores, fusiona los datos duplicados y junta en una sola tabla ambos motores.

En primer lugar se extraen los datos de todos los archivos de cada día y se genera una lista de tablas separadas por motor



In [4]:

    
dia1 = ext.extraer_data('dia1')



In [5]:

    
cd ..









    



/home/rodrigo/dataTritiumWS22



In [6]:

    
dia2 = ext.extraer_data('dia2')



In [7]:

    
cd ..









    



/home/rodrigo/dataTritiumWS22



In [8]:

    
dia3 = ext.extraer_data('dia3')



In [9]:

    
cd ..









    



/home/rodrigo/dataTritiumWS22



In [10]:

    
dia4 = ext.extraer_data('dia4')

Se procesan las listas anteriores, se concatenan por motor según la hora de los registros y se rellenan los espacios vacíos con datos NaN, luego se juntan de costado las tablas (join) y se le añade el sufijo _m1 y _m2 para diferenciar las columnas



In [11]:

    
motoresdia1 = pro.procesar(dia1)



In [12]:

    
motoresdia2 = pro.procesar(dia2)



In [13]:

    
motoresdia3 = pro.procesar(dia3)



In [14]:

    
motoresdia4 = pro.procesar(dia4)

Medimos el número de filas de los archivos (con y sin valores perdidos)



In [15]:

    
con1 , sin1 = len(motoresdia1), len(motoresdia1.dropna())



In [16]:

    
con2 , sin2 = len(motoresdia2), len(motoresdia2.dropna())



In [17]:

    
con3 , sin3 = len(motoresdia3), len(motoresdia3.dropna())



In [18]:

    
con4 , sin4 = len(motoresdia4), len(motoresdia4.dropna())



In [19]:

    
d = {'datos_con_valores_perdidos':[con1,con2,con3,con4],\
     'datos_sin_valores_perdidos':[sin1,sin2,sin3,sin4]}



In [20]:

    
tabla1= pd.DataFrame(d,index=[1,2,3,4])

Visualizamos los datos de la tabla
- La primera columna corresponde al día de competencia
- La segunda indica los datos obtenidos con valores perdidos de uno u otro motor
- La tercera corresponde a los datos en donde ambos motores fueron registrados



In [21]:

    
tabla1









    Out[21]:






  
    
      
      datos_con_valores_perdidos
      datos_sin_valores_perdidos
    
  
  
    
      1
       233002
        80851
    
    
      2
       208236
        83922
    
    
      3
       146330
        33854
    
    
      4
       161647
       133622

Se calcula los datos perdidos por motor



In [22]:

    
m1d1, m2d1 = len(motoresdia1.motorRpm_m1.dropna()),\
             len(motoresdia1.motorRpm_m2.dropna())
m1d2, m2d2 = len(motoresdia2.motorRpm_m1.dropna()),\
             len(motoresdia2.motorRpm_m2.dropna())
m1d3, m2d3 = len(motoresdia3.motorRpm_m1.dropna()),\
             len(motoresdia3.motorRpm_m2.dropna())
m1d4, m2d4 = len(motoresdia4.motorRpm_m1.dropna()),\
             len(motoresdia4.motorRpm_m2.dropna())

Se calcula la relación entre los datos efectivos por motor y el total que registaba cada archivo



In [23]:

    
p1d1, p2d1 = round(m1d1/float(con1),4) , round(m2d1/float(con1),4)



In [24]:

    
p1d2, p2d2 = round(m1d2/float(con2),4) , round(m2d2/float(con2),4)



In [25]:

    
p1d3 , p2d3 = round(m1d3/float(con3),4) , round(m2d3/float(con3),4)



In [26]:

    
p1d4 , p2d4 = round(m1d4/float(con4),4) , round(m2d4/float(con4),4)



In [27]:

    
labels = {'motor1':[100*p1d1, 100*p1d2, 100*p1d3, 100*p1d4],'motor2':\
          [100*p2d1, 100*p2d2, 100*p2d3, 100*p2d4]}



In [28]:

    
tabla2 = pd.DataFrame(labels, index=[1,2,3,4])



In [29]:

    
tabla2

Se observa claramente que el sistema de telemetría usado produjo pérdidas de datos debido a que los programas usados no estaban hechos específicamente para registrar ambos motores, este problema se pudo identificar solamente post-carrera analizando los datos.

En la carrera utilizamos otro sistema auxiliar que capturaba datos, utilizando un arduino y un xbee y los veíamos en tiempo real graficados, sin embargo poseía otros problemas debido a la velocidad de transmisión, y el registro del tiempo es difícil de correlacionar, es menos estándar que es utilizado para este análisis.
Existen dos soluciones al problema, registrar los datos dentro del auto, así se obtendrían todos los datos, y para la telemetría, desarrollar un software para pc que identifique la procedencia y asegure que no se mezclen ni pierdan más datos que los normales en las comunicaciones wireless.

También se observa que la cantidad de datos actuales permite hacer correlaciones con un porcentaje de error aceptable para rellenar los espacios vacíos

De esta manera se podrían hacer cálculos más realistas que los realizados con los archivos en bruto que se realizaron al principio
Como se observa en la tabla 2, el porcentaje de datos perdidos mayoritariamente pertenecen al motor 2 (que debido a otras observaciones de los datos, sabemos que el conjunto motor+ controlador 2 consume menos energía) por ende los cálculos realizados anteriormente de energía consumida debieran ser bastante menores.

	motor1	motor2
1	88.67	45.88
2	99.08	40.43
3	81.64	23.45
4	99.05	82.72